home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / gdb / gdb_18s.zoo / eval.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-25  |  16.8 KB  |  604 lines
  1. /* Evaluate expressions for GDB.
  2.    Copyright (C) 1986, 1987 Free Software Foundation, Inc.
  3.  
  4. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the GDB General Public License for full details.
  9.  
  10. Everyone is granted permission to copy, modify and redistribute GDB,
  11. but only under the conditions described in the GDB General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with GDB so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.  
  17. In other words, go ahead and share GDB, but don't try to stop
  18. anyone else from sharing it farther.  Help stamp out software hoarding!
  19. */
  20.  
  21. #include "defs.h"
  22. #include "symtab.h"
  23. #include "value.h"
  24. #include "expression.h"
  25.  
  26.  
  27. /* Parse the string EXP as a C expression, evaluate it,
  28.    and return the result as a number.  */
  29.  
  30. CORE_ADDR
  31. parse_and_eval_address (exp)
  32.      char *exp;
  33. {
  34.   struct expression *expr = parse_c_expression (exp);
  35.   register CORE_ADDR addr;
  36.   register struct cleanup *old_chain
  37.     = make_cleanup (free_current_contents, &expr);
  38.  
  39.   addr = value_as_long (evaluate_expression (expr));
  40.   do_cleanups (old_chain);
  41.   return addr;
  42. }
  43.  
  44. /* Like parse_and_eval_address but takes a pointer to a char * variable
  45.    and advanced that variable across the characters parsed.  */
  46.  
  47. CORE_ADDR
  48. parse_and_eval_address_1 (expptr)
  49.      char **expptr;
  50. {
  51.   struct expression *expr = parse_c_1 (expptr, 0, 0);
  52.   register CORE_ADDR addr;
  53.   register struct cleanup *old_chain
  54.     = make_cleanup (free_current_contents, &expr);
  55.  
  56.   addr = value_as_long (evaluate_expression (expr));
  57.   do_cleanups (old_chain);
  58.   return addr;
  59. }
  60.  
  61. value
  62. parse_and_eval (exp)
  63.      char *exp;
  64. {
  65.   struct expression *expr = parse_c_expression (exp);
  66.   register value val;
  67.   register struct cleanup *old_chain
  68.     = make_cleanup (free_current_contents, &expr);
  69.  
  70.   val = evaluate_expression (expr);
  71.   do_cleanups (old_chain);
  72.   return val;
  73. }
  74.  
  75. /* Parse up to a comma (or to a closeparen)
  76.    in the string EXPP as an expression, evaluate it, and return the value.
  77.    EXPP is advanced to point to the comma.  */
  78.  
  79. value
  80. parse_to_comma_and_eval (expp)
  81.      char **expp;
  82. {
  83.   struct expression *expr = parse_c_1 (expp, 0, 1);
  84.   register value val;
  85.   register struct cleanup *old_chain
  86.     = make_cleanup (free_current_contents, &expr);
  87.  
  88.   val = evaluate_expression (expr);
  89.   do_cleanups (old_chain);
  90.   return val;
  91. }
  92.  
  93. /* Evaluate an expression in internal prefix form
  94.    such as is constructed by expread.y.
  95.  
  96.    See expression.h for info on the format of an expression.  */
  97.  
  98. static value evaluate_subexp ();
  99. static value evaluate_subexp_for_address ();
  100. static value evaluate_subexp_for_sizeof ();
  101. static value evaluate_subexp_with_coercion ();
  102.  
  103. /* Values of NOSIDE argument to eval_subexp.  */
  104. enum noside
  105. { EVAL_NORMAL, 
  106.   EVAL_SKIP,
  107.   EVAL_AVOID_SIDE_EFFECTS,
  108. };
  109.  
  110. value
  111. evaluate_expression (exp)
  112.      struct expression *exp;
  113. {
  114.   int pc = 0;
  115.   return evaluate_subexp (exp, &pc, EVAL_NORMAL);
  116. }
  117.  
  118. /* Evaluate an expression, avoiding all memory references
  119.    and getting a value whose type alone is correct.  */
  120.  
  121. value
  122. evaluate_type (exp)
  123.      struct expression *exp;
  124. {
  125.   int pc = 0;
  126.   return evaluate_subexp (exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
  127. }
  128.  
  129. static value
  130. evaluate_subexp (exp, pos, noside)
  131.      register struct expression *exp;
  132.      register int *pos;
  133.      enum noside noside;
  134. {
  135.   enum exp_opcode op;
  136.   int tem;
  137.   register int pc;
  138.   register value arg1, arg2;
  139.   int nargs;
  140.   value *argvec;
  141.  
  142.   pc = (*pos)++;
  143.   op = exp->elts[pc].opcode;
  144.  
  145.   switch (op)
  146.     {
  147.     case OP_LONG:
  148.       (*pos) += 3;
  149.       return value_from_long (exp->elts[pc + 1].type,
  150.                   exp->elts[pc + 2].longconst);
  151.  
  152.     case OP_DOUBLE:
  153.       (*pos) += 3;
  154.       return value_from_double (exp->elts[pc + 1].type,
  155.                 exp->elts[pc + 2].doubleconst);
  156.  
  157.     case OP_VAR_VALUE:
  158.       (*pos) += 2;
  159.       if (noside == EVAL_SKIP)
  160.     goto nosideret;
  161.       return value_of_variable (exp->elts[pc + 1].symbol);
  162.  
  163.     case OP_LAST:
  164.       (*pos) += 2;
  165.       return access_value_history (exp->elts[pc + 1].longconst);
  166.  
  167.     case OP_REGISTER:
  168.       (*pos) += 2;
  169.       return value_of_register (exp->elts[pc + 1].longconst);
  170.  
  171.     case OP_INTERNALVAR:
  172.       (*pos) += 2;
  173.       return value_of_internalvar (exp->elts[pc + 1].internalvar);
  174.  
  175.     case OP_FUNCALL:
  176.       (*pos) += 2;
  177.       nargs = exp->elts[pc + 1].longconst;
  178.       argvec = (value *) alloca (sizeof (value) * (nargs + 2));
  179.       for (tem = 0; tem <= nargs; tem++)
  180.  
  181.     /* Ensure that array expressions are coerced into pointer objects. */
  182.     argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
  183.       /* signal end of arglist */
  184.       argvec[tem] = 0;
  185.  
  186.       if (noside == EVAL_SKIP)
  187.     goto nosideret;
  188.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  189.     return allocate_value (TYPE_TARGET_TYPE (VALUE_TYPE (argvec[0])));
  190.       return call_function (argvec[0], nargs, argvec + 1);
  191.  
  192.     case OP_STRING:
  193.       tem = strlen (&exp->elts[pc + 1].string);
  194.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  195.       if (noside == EVAL_SKIP)
  196.     goto nosideret;
  197.       return value_string (&exp->elts[pc + 1].string, tem);
  198.  
  199.     case TERNOP_COND:
  200.       /* Skip third and second args to evaluate the first one.  */
  201.       arg1 = evaluate_subexp (exp, pos, noside);
  202.       if (value_zerop (arg1))
  203.     {
  204.       evaluate_subexp (exp, pos, EVAL_SKIP);
  205.       return evaluate_subexp (exp, pos, noside);
  206.     }
  207.       else
  208.     {
  209.       arg2 = evaluate_subexp (exp, pos, noside);
  210.       evaluate_subexp (exp, pos, EVAL_SKIP);
  211.       return arg2;
  212.     }
  213.  
  214.     case STRUCTOP_STRUCT:
  215.       tem = strlen (&exp->elts[pc + 1].string);
  216.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  217.       arg1 = evaluate_subexp (exp, pos, noside);
  218.       if (noside == EVAL_SKIP)
  219.     goto nosideret;
  220.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  221. #if 0
  222.     return value_zero (lookup_struct_elt_type (VALUE_TYPE (arg1),
  223.                            &exp->elts[pc + 1].string,
  224.                            1),
  225.                lval_memory);
  226. #else
  227.     goto nosideret;
  228. #endif
  229.       else
  230.       {
  231.       value temp = arg1;
  232.       
  233.       return value_struct_elt (temp, &exp->elts[pc + 1].string,
  234.                    "structure");
  235.       }
  236.  
  237.     case STRUCTOP_PTR:
  238.       tem = strlen (&exp->elts[pc + 1].string);
  239.       (*pos) += 2 + (tem + sizeof (union exp_element)) / sizeof (union exp_element);
  240.       arg1 = evaluate_subexp (exp, pos, noside);
  241.       if (noside == EVAL_SKIP)
  242.     goto nosideret;
  243.       if (noside == EVAL_AVOID_SIDE_EFFECTS)
  244. #if 0
  245.     return value_zero (lookup_struct_elt_type (TYPE_TARGET_TYPE
  246.                            (VALUE_TYPE (arg1)),
  247.                            &exp->elts[pc + 1].string,
  248.                            1),
  249.                lval_memory);
  250. #else
  251.     goto nosideret;
  252. #endif
  253.       else
  254.       {
  255.           value temp = arg1;
  256.       return value_struct_elt (temp, &exp->elts[pc + 1].string,
  257.                    "structure pointer");
  258.       }
  259.       
  260.     case BINOP_ASSIGN:
  261.       arg1 = evaluate_subexp (exp, pos, noside);
  262.       arg2 = evaluate_subexp (exp, pos, noside);
  263.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  264.     return arg1;
  265.       return value_assign (arg1, arg2);
  266.  
  267.     case BINOP_ASSIGN_MODIFY:
  268.       (*pos) += 2;
  269.       arg1 = evaluate_subexp (exp, pos, noside);
  270.       arg2 = evaluate_subexp (exp, pos, noside);
  271.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  272.     return arg1;
  273.       op = exp->elts[pc + 1].opcode;
  274.       if (op == BINOP_ADD)
  275.     arg2 = value_add (arg1, arg2);
  276.       else if (op == BINOP_SUB)
  277.     arg2 = value_sub (arg1, arg2);
  278.       else
  279.     arg2 = value_binop (arg1, arg2, op);
  280.       return value_assign (arg1, arg2);
  281.  
  282.     case BINOP_ADD:
  283.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  284.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  285.       if (noside == EVAL_SKIP)
  286.     goto nosideret;
  287.       return value_add (arg1, arg2);
  288.  
  289.     case BINOP_SUB:
  290.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  291.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  292.       if (noside == EVAL_SKIP)
  293.     goto nosideret;
  294.       return value_sub (arg1, arg2);
  295.  
  296.     case BINOP_MUL:
  297.     case BINOP_DIV:
  298.     case BINOP_REM:
  299.     case BINOP_LSH:
  300.     case BINOP_RSH:
  301.     case BINOP_LOGAND:
  302.     case BINOP_LOGIOR:
  303.     case BINOP_LOGXOR:
  304.       arg1 = evaluate_subexp (exp, pos, noside);
  305.       arg2 = evaluate_subexp (exp, pos, noside);
  306.       if (noside == EVAL_SKIP)
  307.     goto nosideret;
  308.       return value_binop (arg1, arg2, op);
  309.  
  310.     case BINOP_SUBSCRIPT:
  311.       arg1 = evaluate_subexp_with_coercion (exp, pos, noside);
  312.       arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
  313.       if (noside == EVAL_SKIP)
  314.     goto nosideret;
  315.       return value_subscript (arg1, arg2, op);
  316.       
  317.     case BINOP_AND:
  318.       arg1 = evaluate_subexp (exp, pos, noside);
  319.       tem = value_zerop (arg1);
  320.       arg2 = evaluate_subexp (exp, pos,
  321.                   (tem ? EVAL_SKIP : noside));
  322.       return value_from_long (builtin_type_int,
  323.                   !tem && !value_zerop (arg2));
  324.  
  325.     case BINOP_OR:
  326.       arg1 = evaluate_subexp (exp, pos, noside);
  327.       tem = value_zerop (arg1);
  328.       arg2 = evaluate_subexp (exp, pos,
  329.                   (!tem ? EVAL_SKIP : noside));
  330.       return value_from_long (builtin_type_int,
  331.                   !tem || !value_zerop (arg2));
  332.  
  333.     case BINOP_EQUAL:
  334.       arg1 = evaluate_subexp (exp, pos, noside);
  335.       arg2 = evaluate_subexp (exp, pos, noside);
  336.       if (noside == EVAL_SKIP)
  337.     goto nosideret;
  338.       tem = value_equal (arg1, arg2);
  339.       return value_from_long (builtin_type_int, tem);
  340.  
  341.     case BINOP_NOTEQUAL:
  342.       arg1 = evaluate_subexp (exp, pos, noside);
  343.       arg2 = evaluate_subexp (exp, pos, noside);
  344.       if (noside == EVAL_SKIP)
  345.     goto nosideret;
  346.       tem = value_equal (arg1, arg2);
  347.       return value_from_long (builtin_type_int, ! tem);
  348.  
  349.     case BINOP_LESS:
  350.       arg1 = evaluate_subexp (exp, pos, noside);
  351.       arg2 = evaluate_subexp (exp, pos, noside);
  352.       if (noside == EVAL_SKIP)
  353.     goto nosideret;
  354.       tem = value_less (arg1, arg2);
  355.       return value_from_long (builtin_type_int, tem);
  356.  
  357.     case BINOP_GTR:
  358.       arg1 = evaluate_subexp (exp, pos, noside);
  359.       arg2 = evaluate_subexp (exp, pos, noside);
  360.       if (noside == EVAL_SKIP)
  361.     goto nosideret;
  362.       tem = value_less (arg2, arg1);
  363.       return value_from_long (builtin_type_int, tem);
  364.  
  365.     case BINOP_GEQ:
  366.       arg1 = evaluate_subexp (exp, pos, noside);
  367.       arg2 = evaluate_subexp (exp, pos, noside);
  368.       if (noside == EVAL_SKIP)
  369.     goto nosideret;
  370.       tem = value_less (arg1, arg2);
  371.       return value_from_long (builtin_type_int, ! tem);
  372.  
  373.     case BINOP_LEQ:
  374.       arg1 = evaluate_subexp (exp, pos, noside);
  375.       arg2 = evaluate_subexp (exp, pos, noside);
  376.       if (noside == EVAL_SKIP)
  377.     goto nosideret;
  378.       tem = value_less (arg2, arg1);
  379.       return value_from_long (builtin_type_int, ! tem);
  380.  
  381.     case BINOP_REPEAT:
  382.       arg1 = evaluate_subexp (exp, pos, noside);
  383.       arg2 = evaluate_subexp (exp, pos, noside);
  384.       if (noside == EVAL_SKIP)
  385.     goto nosideret;
  386.       return value_repeat (arg1, value_as_long (arg2));
  387.  
  388.     case BINOP_COMMA:
  389.       evaluate_subexp (exp, pos, noside);
  390.       return evaluate_subexp (exp, pos, noside);
  391.  
  392.     case UNOP_NEG:
  393.       arg1 = evaluate_subexp (exp, pos, noside);
  394.       if (noside == EVAL_SKIP)
  395.     goto nosideret;
  396.       return value_neg (arg1);
  397.  
  398.     case UNOP_LOGNOT:
  399.       arg1 = evaluate_subexp (exp, pos, noside);
  400.       if (noside == EVAL_SKIP)
  401.     goto nosideret;
  402.       return value_lognot (arg1);
  403.  
  404.     case UNOP_ZEROP:
  405.       arg1 = evaluate_subexp (exp, pos, noside);
  406.       if (noside == EVAL_SKIP)
  407.     goto nosideret;
  408.       return value_from_long (builtin_type_int, value_zerop (arg1));
  409.  
  410.     case UNOP_IND:
  411.       arg1 = evaluate_subexp (exp, pos, noside);
  412.       if (noside == EVAL_SKIP)
  413.     goto nosideret;
  414.       return value_ind (arg1);
  415.  
  416.     case UNOP_ADDR:
  417.       if (noside == EVAL_SKIP)
  418.     {
  419.       evaluate_subexp (exp, pos, EVAL_SKIP);
  420.       goto nosideret;
  421.     }
  422.       return evaluate_subexp_for_address (exp, pos, noside);
  423.  
  424.     case UNOP_SIZEOF:
  425.       if (noside == EVAL_SKIP)
  426.     {
  427.       evaluate_subexp (exp, pos, EVAL_SKIP);
  428.       goto nosideret;
  429.     }
  430.       return evaluate_subexp_for_sizeof (exp, pos);
  431.  
  432.     case UNOP_CAST:
  433.       (*pos) += 2;
  434.       arg1 = evaluate_subexp (exp, pos, noside);
  435.       if (noside == EVAL_SKIP)
  436.     goto nosideret;
  437.       return value_cast (exp->elts[pc + 1].type, arg1);
  438.  
  439.     case UNOP_MEMVAL:
  440.       (*pos) += 2;
  441.       arg1 = evaluate_subexp (exp, pos, noside);
  442.       if (noside == EVAL_SKIP)
  443.     goto nosideret;
  444.       return value_at (exp->elts[pc + 1].type, value_as_long (arg1));
  445.  
  446.     case UNOP_PREINCREMENT:
  447.       arg1 = evaluate_subexp (exp, pos, noside);
  448.       arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
  449.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  450.     return arg1;
  451.       return value_assign (arg1, arg2);
  452.  
  453.     case UNOP_PREDECREMENT:
  454.       arg1 = evaluate_subexp (exp, pos, noside);
  455.       arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
  456.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  457.     return arg1;
  458.       return value_assign (arg1, arg2);
  459.  
  460.     case UNOP_POSTINCREMENT:
  461.       arg1 = evaluate_subexp (exp, pos, noside);
  462.       arg2 = value_add (arg1, value_from_long (builtin_type_char, 1));
  463.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  464.     return arg1;
  465.       value_assign (arg1, arg2);
  466.       return arg1;
  467.  
  468.     case UNOP_POSTDECREMENT:
  469.       arg1 = evaluate_subexp (exp, pos, noside);
  470.       arg2 = value_sub (arg1, value_from_long (builtin_type_char, 1));
  471.       if (noside == EVAL_SKIP || noside == EVAL_AVOID_SIDE_EFFECTS)
  472.     return arg1;
  473.       value_assign (arg1, arg2);
  474.       return arg1;
  475.  
  476.     default:
  477.       error ("internal error: I do not know how to evaluate what you gave me");
  478.     }
  479.  
  480.  nosideret:
  481.   return value_from_long (builtin_type_long, 1);
  482. }
  483.  
  484. /* Evaluate a subexpression of EXP, at index *POS,
  485.    and return the address of that subexpression.
  486.    Advance *POS over the subexpression.
  487.    If the subexpression isn't an lvalue, get an error.
  488.    NOSIDE may be EVAL_AVOID_SIDE_EFFECTS;
  489.    then only the type of the result need be correct.  */
  490.  
  491. static value
  492. evaluate_subexp_for_address (exp, pos, noside)
  493.      register struct expression *exp;
  494.      register int *pos;
  495.      enum noside noside;
  496. {
  497.   enum exp_opcode op;
  498.   register int pc;
  499.  
  500.   pc = (*pos);
  501.   op = exp->elts[pc].opcode;
  502.  
  503.   switch (op)
  504.     {
  505.     case UNOP_IND:
  506.       (*pos)++;
  507.       return evaluate_subexp (exp, pos, noside);
  508.  
  509.     case UNOP_MEMVAL:
  510.       (*pos) += 3;
  511.       return value_cast (lookup_pointer_type (exp->elts[pc + 1].type),
  512.              evaluate_subexp (exp, pos, noside));
  513.  
  514.     case OP_VAR_VALUE:
  515.       (*pos) += 3;
  516.       return locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
  517.  
  518.     default:
  519.       return value_addr (evaluate_subexp (exp, pos, noside));
  520.     }
  521. }
  522.  
  523. /* Evaluate like `evaluate_subexp' except coercing arrays to pointers.
  524.    When used in contexts where arrays will be coerced anyway,
  525.    this is equivalent to `evaluate_subexp'
  526.    but much faster because it avoids actually fetching array contents.  */
  527.  
  528. static value
  529. evaluate_subexp_with_coercion (exp, pos, noside)
  530.      register struct expression *exp;
  531.      register int *pos;
  532.      enum noside noside;
  533. {
  534.   register enum exp_opcode op;
  535.   register int pc;
  536.   register value val;
  537.  
  538.   pc = (*pos);
  539.   op = exp->elts[pc].opcode;
  540.  
  541.   switch (op)
  542.     {
  543.     case OP_VAR_VALUE:
  544.       if (TYPE_CODE (SYMBOL_TYPE (exp->elts[pc + 1].symbol)) == TYPE_CODE_ARRAY)
  545.     {
  546.       (*pos) += 3;
  547.       val = locate_var_value (exp->elts[pc + 1].symbol, (CORE_ADDR) 0);
  548.       return value_cast (lookup_pointer_type (TYPE_TARGET_TYPE (SYMBOL_TYPE (exp->elts[pc + 1].symbol))),
  549.                  val);
  550.     }
  551.     default:
  552.       return evaluate_subexp (exp, pos, noside);
  553.     }
  554. }
  555.  
  556. /* Evaluate a subexpression of EXP, at index *POS,
  557.    and return a value for the size of that subexpression.
  558.    Advance *POS over the subexpression.  */
  559.  
  560. static value
  561. evaluate_subexp_for_sizeof (exp, pos)
  562.      register struct expression *exp;
  563.      register int *pos;
  564. {
  565.   enum exp_opcode op;
  566.   register int pc;
  567.   value val;
  568.  
  569.   pc = (*pos);
  570.   op = exp->elts[pc].opcode;
  571.  
  572.   switch (op)
  573.     {
  574.       /* This case is handled specially
  575.      so that we avoid creating a value for the result type.
  576.      If the result type is very big, it's desirable not to
  577.      create a value unnecessarily.  */
  578.     case UNOP_IND:
  579.       (*pos)++;
  580.       val = evaluate_subexp (exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  581.       return value_from_long (builtin_type_int,
  582.                   TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
  583.  
  584.     case UNOP_MEMVAL:
  585.       (*pos) += 3;
  586.       return value_from_long (builtin_type_int,
  587.                   TYPE_LENGTH (exp->elts[pc + 1].type));
  588.  
  589.     case OP_VAR_VALUE:
  590.       (*pos) += 3;
  591.       return value_from_long (builtin_type_int,
  592.                   TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 1].symbol)));
  593.  
  594.     default:
  595.       val = evaluate_subexp (exp, pos, EVAL_AVOID_SIDE_EFFECTS);
  596.       return value_from_long (builtin_type_int,
  597.                   TYPE_LENGTH (VALUE_TYPE (val)));
  598.     }
  599. }
  600.  
  601. void
  602. initialize_eval ()
  603. { }
  604.